%matplotlib inline
from matplotlib import pylab as plt
import theano
from theano import tensor as T
import numpy as np

#create a regular grid in weight space for visualisation
wmin = -5
wmax = 5
wrange = np.linspace(wmin,wmax,300)
w = np.repeat(wrange[:,None],300,axis=1)
w = np.concatenate([[w.flatten()],[w.T.flatten()]])

w_grid = np.dstack(np.mgrid[wmin:wmax:300j,wmin:wmax:300j])
w_grid_flat = w_grid.reshape(300*300,2).T

w_grid.shape

(300, 300, 2)

w[...,:5]

array([[-5.        , -5.        , -5.        , -5.        , -5.        ],
       [-5.        , -4.96655518, -4.93311037, -4.89966555, -4.86622074]])

np.all(w.T.reshape(300,300,2)==w_grid)

True

np.all(w_grid_flat==w)

True

prior_variance = 2
logprior = -(w**2).sum(axis=0)/2/prior_variance
plt.contourf(wrange, wrange, logprior.reshape(300,300), cmap='gray');
plt.axis('square');
plt.xlim([wmin,wmax])
plt.ylim([wmin,wmax])

prior_variance = 2
logprior = -(w**2).sum(axis=0)/2/prior_variance
plt.contourf(wrange, wrange, logprior.reshape(300,300), cmap='gray');
plt.axis('square');
plt.xlim([wmin,wmax])
plt.ylim([wmin,wmax]);

#generating a toy dataset with three manually selected observations
from scipy.stats import logistic
sigmoid = logistic.cdf
logsigmoid = logistic.logcdf

def likelihood(w,x,b=0,y=1):
    return logsigmoid(y*(np.dot(w.T,x) + b)).flatten()


x1 = np.array([[1.5],[1]])
x2 = np.array([[-1.5],[1]])
x3 = np.array([[0.5],[-1]])

y1=1
y2=1
y3=-1

llh1 = likelihood(w, x1, y=y1) 
llh2 = likelihood(w, x2, y=y2) 
llh3 = likelihood(w, x3, y=y3) 

#calculating unnormalised log posterior
#this is only for illustration
logpost = llh1 + llh2 + llh3 + logprior

#plotting the real log posterior
#the red dots show the three datapoints, the small line segments shows the direction
#in which the corresponding label shifts the posterior. Positive datapoints shift the 
# posterior away from zero in the direction of the datapoint, negative datapoints shift
# away from zero, in the opposite direction.

plt.contourf(wrange,
             wrange,
             np.exp(logpost.reshape(300,300).T),cmap='gray');
plt.axis('square');
plt.xlim([wmin,wmax])
plt.ylim([wmin,wmax])

plt.plot(x1[0],x1[1],'.r')
plt.plot([x1[0],x1[0]*(1+0.2*y1)],[x1[1],x1[1]*(1+0.2*y1)],'r-')

plt.plot(x2[0],x2[1],'.r')
plt.plot([x2[0],x2[0]*(1+0.2*y2)],[x2[1],x2[1]*(1+0.2*y2)],'r-')

plt.plot(x3[0],x3[1],'.r')
plt.plot([x3[0],x3[0]*(1+0.2*y3)],[x3[1],x3[1]*(1+0.2*y3)],'r-');

Fitting an approximate posterior

This part is for the actual GAN stuff. Here we define the generator and the discriminator networks in Lasagne, and code up the two loss functions in theano.

from lasagne.utils import floatX

from lasagne.layers import (
    InputLayer,
    DenseLayer,
    NonlinearityLayer)
from lasagne.nonlinearities import sigmoid

#defines a 'generator' network
def build_G(input_var=None, num_z = 3):
    
    network = InputLayer(input_var=input_var, shape=(None, num_z))
    
    network = DenseLayer(incoming = network, num_units=10)
    
    network = DenseLayer(incoming = network, num_units=20)
    
    network = DenseLayer(incoming = network, num_units=2, nonlinearity=None)
    
    return network

#defines the 'discriminator network'
def build_D(input_var=None):

    network = InputLayer(input_var=input_var, shape = (None, 2))
    
    network = DenseLayer(incoming = network, num_units=10)
    
    network = DenseLayer(incoming = network, num_units=20)
    
    network = DenseLayer(incoming = network, num_units=1, nonlinearity=None)
    
    normalised = NonlinearityLayer(incoming = network, nonlinearity = sigmoid)
    
    return { 'unnorm':network, 'norm':normalised }

/Users/tiao/.virtualenvs/implicit/lib/python3.6/site-packages/theano/tensor/signal/downsample.py:6: UserWarning: downsample module has been moved to the theano.tensor.signal.pool module.
  "downsample module has been moved to the theano.tensor.signal.pool module.")

from lasagne.layers import get_output, get_all_params
from theano.printing import debugprint
from lasagne.updates import adam
from theano.tensor.shared_randomstreams import RandomStreams

#variables for input (design matrix), output labels, GAN noise variable, weights
x_var = T.matrix('design matrix')
y_var = T.vector('labels')
z_var = T.matrix('GAN noise')
w_var = T.matrix('weights')

#theano variables for things like batchsize, learning rate, etc.
batchsize_var = T.scalar('batchsize', dtype='int32')
prior_variance_var = T.scalar('prior variance')
learningrate_var = T.scalar('learning rate')

#random numbers for sampling from the prior or from the GAN
srng = RandomStreams(seed=1337)
z_rnd = srng.normal((batchsize_var,3))
prior_rnd = srng.normal((batchsize_var,2))

#instantiating the G and D networks
generator = build_G(z_var)
discriminator = build_D()

#these expressions are random samples from the generator and the prior, respectively
samples_from_grenerator = get_output(generator, z_rnd)
samples_from_prior = prior_rnd*T.sqrt(prior_variance_var)

#discriminator output for synthetic samples, both normalised and unnormalised (after/before sigmoid)
D_of_G = get_output(discriminator['norm'], inputs=samples_from_grenerator)
s_of_G = get_output(discriminator['unnorm'], inputs=samples_from_grenerator)

#discriminator output for real samples from the prior
D_of_prior = get_output(discriminator['norm'], inputs=samples_from_prior)

#loss of discriminator - simple binary cross-entropy loss
loss_D = -T.log(D_of_G).mean() - T.log(1-D_of_prior).mean()

#log likelihood for each synthetic w sampled from the generator
log_likelihood = T.log(
    T.nnet.sigmoid(
        (y_var.dimshuffle(0,'x','x')*(x_var.dimshuffle(0,1,'x') * samples_from_grenerator.dimshuffle('x', 1, 0))).sum(1)
    )
).sum(0).mean()

#loss for G is the sum of unnormalised discriminator output and the negative log likelihood
loss_G = s_of_G.mean() - log_likelihood

#compiling theano functions:
evaluate_generator = theano.function(
    [z_var],
    get_output(generator),
    allow_input_downcast=True
)

sample_generator = theano.function(
    [batchsize_var],
    samples_from_grenerator,
    allow_input_downcast=True,
)

sample_prior = theano.function(
    [prior_variance_var, batchsize_var],
    samples_from_prior,
    allow_input_downcast=True
)

params_D = get_all_params(discriminator['norm'], trainable=True)

updates_D = adam(
    loss_D,
    params_D,
    learning_rate = learningrate_var
)

train_D = theano.function(
    [learningrate_var, batchsize_var, prior_variance_var],
    loss_D,
    updates = updates_D,
    allow_input_downcast = True
)

params_G = get_all_params(generator, trainable=True)

updates_G = adam(
    loss_G,
    params_G,
    learning_rate = learningrate_var
)

train_G = theano.function(
    [x_var, y_var, learningrate_var, batchsize_var],
    loss_G,
    updates = updates_G,
    allow_input_downcast = True
)

evaluate_discriminator = theano.function(
    [w_var],
    get_output([discriminator['unnorm'],discriminator['norm']],w_var),
    allow_input_downcast = True
)

#this is to evaluate the log-likelihood of an arbitrary set of w
llh_for_w = T.nnet.sigmoid((y_var.dimshuffle(0,'x','x')*(x_var.dimshuffle(0,1,'x') * w_var.dimshuffle('x', 1, 0))).sum(1))

evaluate_loglikelihood = theano.function(
        [x_var, y_var, w_var],
        llh_for_w,
        allow_input_downcast = True
    )

#checking that theano and numpy give the same likelihoods
import seaborn as sns
sns.set_context('poster')

X_train = np.concatenate([x1,x2,x3],axis=1).T
y_train = np.array([y1,y2,y3])
llh_theano = evaluate_loglikelihood(X_train, y_train, w.T)

plt.figure(figsize=(16,8))
plt.subplot(1,2,1)
plt.contourf(wrange, wrange ,np.log(llh_theano).sum(0).reshape(300,300).T,cmap='gray');
plt.axis('square');
plt.xlim([wmin,wmax])
plt.ylim([wmin,wmax])
plt.title('theano loglikelihood')

plt.subplot(1,2,2)
plt.contourf(wrange, wrange, (llh1+llh2+llh3).reshape(300,300).T,cmap='gray');
plt.axis('square');
plt.xlim([wmin,wmax])
plt.ylim([wmin,wmax])
plt.title('numpy loglikelihood')

assert np.allclose(llh1+llh2+llh3,np.log(llh_theano).sum(0))

batchsize = 200
KARPATHY_CONSTANT = 3e-4
learning_rate = KARPATHY_CONSTANT*10

prior_variance = 2
# train discriminator for some time before starting iterative process
%timeit -n 300 train_D(learning_rate, batchsize, prior_variance)
# print initial values of training errors
print (train_D(0, 100, prior_variance))
print (train_G(X_train, y_train, 0, batchsize))
for i in range(200):
    %timeit -n 50 train_D(learning_rate, batchsize, prior_variance)
    print (train_D(0, 100, prior_variance))
    print (train_G(X_train, y_train, 0, 100))
    train_G(X_train, y_train, learning_rate, batchsize)

756 µs ± 271 µs per loop (mean ± std. dev. of 7 runs, 300 loops each)
0.33257354666094224
4.996102628755116
490 µs ± 21.7 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.2119455387013967
4.1202309895028835
554 µs ± 110 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.3581621228462506
4.707070363772413
525 µs ± 50.7 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.21017178628830308
4.276304144298293
578 µs ± 103 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.40397309168350565
4.372633122086429
1.03 ms ± 469 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.46383786347060996
4.2827275263065765
532 µs ± 81.4 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.4742954938839633
4.3077686017458054
531 µs ± 84.5 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.4121499447379206
4.397708586401626
593 µs ± 156 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.44319494364792195
3.980595081088458
1.08 ms ± 449 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.42927350789948465
3.7900577311949553
852 µs ± 403 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.46957103677027356
3.710435643364359
806 µs ± 297 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.3602928390303859
3.4830954212562526
1.08 ms ± 245 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.40927156952073895
3.4364983784929883
761 µs ± 94.1 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.50816115146877
3.599252549464353
531 µs ± 41.9 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.6243425998036307
3.3147001872257293
885 µs ± 255 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.5214014031521584
3.2957678425189454
509 µs ± 51.6 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.5777377856471808
3.3931108838380686
527 µs ± 66.2 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.5769061981295343
2.9636664857310944
533 µs ± 40.5 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.5919845798230468
3.0980678544245177
585 µs ± 120 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.5221136104884718
2.9536828849957484
475 µs ± 11.2 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.5899299184472118
3.018050123719444
514 µs ± 70.5 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.5763176714698327
2.7836889692763553
515 µs ± 67.1 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.6867567169306564
2.7724327113426255
846 µs ± 221 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.6660490357124809
2.6334797044549028
503 µs ± 14.7 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.6661692478486261
2.798222159866464
577 µs ± 79.6 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.6284425682323345
2.45941002566091
616 µs ± 135 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.7538949350668582
2.5561553966818646
857 µs ± 326 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.6784818173772513
2.5707759109406383
662 µs ± 184 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.6106598836310618
2.4423542734158934
504 µs ± 53 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.7322285427403872
2.486232874363383
551 µs ± 82 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.5639550073386318
2.6146086412137772
979 µs ± 542 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.7264087412017558
2.4332230875462812
482 µs ± 16.9 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.7283933854707818
2.3681987399338826
530 µs ± 73.4 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.6657642175741061
2.3105561541710573
1.03 ms ± 382 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.7455752044114734
2.3375515479136095
509 µs ± 15.5 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.695036638914291
2.241469415845449
612 µs ± 191 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8288253950300575
2.1713170188630624
540 µs ± 41.6 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.7325451695034837
2.3926006731706173
528 µs ± 39.2 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.6537477437558776
2.221071531153876
474 µs ± 12.4 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.6594337612422132
2.0842268725820223
548 µs ± 75.3 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.7937575616200123
2.287965474601517
639 µs ± 181 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.7824615530138115
2.2032675608338157
498 µs ± 30.9 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.7041354493336556
2.223044383372638
499 µs ± 38.6 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.7809340654032331
2.2406197901191884
552 µs ± 104 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8560787560241433
2.242268627133387
544 µs ± 80.5 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8250840009584233
2.0697757387240405
485 µs ± 16.3 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8030169872590546
2.168738405634988
497 µs ± 20.2 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.7411801737133148
2.073490427374885
481 µs ± 17.9 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.6817005099920493
2.030122806263039
500 µs ± 27.5 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.7137601683021236
2.0777852018070595
485 µs ± 14.3 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8651488860181719
2.0226483968095486
552 µs ± 81.8 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.835908020892067
2.0074897300615877
477 µs ± 17.3 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.758321051598106
1.9466429535011147
495 µs ± 27.7 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.7774988089743448
2.0646111589711773
529 µs ± 52.9 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9320844472032326
2.059555610186674
1.03 ms ± 545 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8995300497945045
2.096498881611496
509 µs ± 34.4 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8120412541290547
2.0689781803221026
542 µs ± 70.4 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8022209799129976
2.006215299988812
505 µs ± 41.3 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9861490734907152
2.08059183752742
680 µs ± 176 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.0280314462199212
1.990792685262567
874 µs ± 198 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9207858693798733
2.0218614795917036
663 µs ± 256 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9208536630021291
2.058661662973811
723 µs ± 181 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.7806616908852124
2.092379434684223
482 µs ± 14.4 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.7260779512186379
2.1071780917151113
570 µs ± 157 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8798079764013904
1.8842698809942315
540 µs ± 29.7 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.7932729045583661
2.0850770570680015
546 µs ± 55.2 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8061788863252047
2.040032451204915
470 µs ± 10.1 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8073895158455865
1.975324924853765
512 µs ± 39.7 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8935399317474548
2.0107243214818857
500 µs ± 20.5 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9027509732177925
1.938966456452621
562 µs ± 57.4 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9321444061436406
2.000069069107975
473 µs ± 8.21 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8318318871623693
1.9559127147670219
626 µs ± 178 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8517743244973623
1.958692968227925
480 µs ± 9.61 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9480755619110519
2.0338699768603945
1.06 ms ± 508 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8165538496544358
2.0816034247398614
488 µs ± 37.6 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.0169935523291809
2.002750951769813
601 µs ± 83.8 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8609770779991297
1.8982912711475097
607 µs ± 62.6 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8046362052484096
1.9086013477667225
553 µs ± 43.6 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9325364646910803
1.9109967613404208
511 µs ± 53.2 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.0304139762238786
1.9654525015937858
505 µs ± 57.5 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.0540401463614057
1.9582530556159827
562 µs ± 77.5 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.914125377935025
1.8530085305028012
472 µs ± 17.2 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9448266113197814
1.9636818919264836
528 µs ± 70.2 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.963835996295888
1.894341290727306
797 µs ± 237 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8615783954534084
1.9528007843738875
472 µs ± 20 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.7910335704428098
1.9388852726528625
501 µs ± 58.2 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8739924169364888
1.9559208529674579
513 µs ± 113 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9051278386689579
1.8909948941135415
841 µs ± 81.8 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8813494975055529
1.9817322193447398
1.1 ms ± 363 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9470555429508094
1.9069496146627483
904 µs ± 167 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.7877545237634651
1.9702616998910425
972 µs ± 128 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9205211070750159
2.014370612501838
1.13 ms ± 384 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.933990121985794
1.9095942141322215
748 µs ± 195 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9475402208390824
1.9494076334790447
576 µs ± 54.8 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8589765045801104
1.889592058420883
1.4 ms ± 659 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8563859315740332
1.8689975224271627
740 µs ± 77.3 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.928830260548582
1.8557579356544007
769 µs ± 68.4 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8437500234877205
1.9174548373736333
1.64 ms ± 439 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8850338692176746
2.0134683306049777
716 µs ± 51 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9338067281411887
1.9767214145036887
919 µs ± 537 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8205574093839865
1.7944354402306084
1.67 ms ± 530 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9737491365943363
1.951982798855767
1.53 ms ± 258 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9470174094386663
1.8578685241325357
1.4 ms ± 138 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.0005854999605033
1.9212340122496618
1.51 ms ± 242 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9273271404185992
1.8973621424806635
1.61 ms ± 604 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.0220764708611707
1.9472312379222265
2.08 ms ± 548 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9248811191718072
1.8928291855604598
1.06 ms ± 286 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8290740848746385
1.8897263331754375
694 µs ± 27.3 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9799797827702561
1.952145411391983
791 µs ± 84.1 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9405966189131413
1.9026507286851595
1.19 ms ± 451 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9772764762220023
1.9203726525414786
754 µs ± 149 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.0202258803759694
1.849928464204487
741 µs ± 49.9 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.0584196314490577
1.8841021134541438
748 µs ± 28.7 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9354598685244473
1.9313836408226328
875 µs ± 274 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.0344390971829374
1.8982657302884327
970 µs ± 328 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9304285291095017
1.865926431269422
708 µs ± 27.9 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8619103690449218
1.9286916051702754
759 µs ± 34 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.0140179780608727
1.8924410298302774
994 µs ± 203 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8577751186154285
1.88701888782196
705 µs ± 37.6 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9723147845176738
1.8821015113591535
726 µs ± 52.1 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9939406608492074
1.8880703013393
712 µs ± 37.5 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.0408800713205586
1.9248629503590609
704 µs ± 37.7 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9584778676205794
1.8842226406928675
718 µs ± 61 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8779676454323607
1.9256547680245397
687 µs ± 13.8 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.0903055260322778
1.8867120123836676
737 µs ± 57.2 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.950257682528716
1.879053173611434
790 µs ± 89.8 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.0122997217021872
1.8890781635072065
747 µs ± 89.6 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9679689464883663
1.872122699531169
689 µs ± 12.5 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9096320417130161
1.923981415466368
748 µs ± 170 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.0781932512358905
1.9057818053352777
779 µs ± 137 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.0215196987892357
1.9189415812174135
777 µs ± 101 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9232977516007778
1.8273955416564407
785 µs ± 62.9 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9041884309796195
1.9066577343610374
1.04 ms ± 339 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9252223734993067
1.8814625440993034
917 µs ± 290 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8495598868404447
1.8300689253833733
743 µs ± 124 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.0765161414654125
1.8574254538123613
921 µs ± 318 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8161981092285884
1.8785336282001959
852 µs ± 171 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8397428807457661
1.9578194249892404
862 µs ± 213 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.0174859132107457
1.8849735639470198
764 µs ± 92.8 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8959106723444588
1.9333336705675197
783 µs ± 105 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.7916593306788984
1.9545142441497103
746 µs ± 49.2 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8812807784690273
1.8874628882436206
697 µs ± 11.7 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8673166863772079
1.9080597422636205
693 µs ± 10.2 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9367052052889462
1.885876287477752
862 µs ± 159 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9497331474099853
1.8672346413971976
716 µs ± 74.7 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9266406126684528
1.9517809122012415
727 µs ± 78.6 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9562966072014943
1.8804970072650735
740 µs ± 91.9 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9132301479427516
1.869284506246696
808 µs ± 118 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.923745649712572
1.8763534495471965
779 µs ± 67 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9287994767930432
1.8716414936200356
848 µs ± 136 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.977270467078829
1.947800409801077
806 µs ± 142 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9244729602885968
1.9226978447893457
538 µs ± 63.1 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9311189691484028
1.8837286976574859
530 µs ± 72.2 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8594519610091946
1.9563857351539964
583 µs ± 81.1 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9406141294930126
1.9025527526374169
501 µs ± 82 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.060407851595865
1.8790415774849558
584 µs ± 186 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9263146702991807
1.9159754127656088
464 µs ± 6.96 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.902627280762216
1.8929628711058266
559 µs ± 49.7 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.940825833072022
1.9478878029088262
521 µs ± 76.3 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9345100510488324
1.9208407501589857
535 µs ± 58.9 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.0616573458438032
1.893844467893682
560 µs ± 73 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9259801183968952
1.9219868429525562
593 µs ± 122 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9248751926178794
1.8443098633578021
519 µs ± 96.8 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9872254701426095
1.9010606743345368
592 µs ± 146 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.966836792989094
1.9708824559631077
550 µs ± 74.3 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.142821965169572
1.9081736991446854
516 µs ± 58.3 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.0132293465630695
1.9089849085528217
560 µs ± 88.4 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.0953773163963214
1.946396226757867
502 µs ± 13.5 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9454524901139612
1.8971714273008042
517 µs ± 51.3 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8541163678880714
1.909320854049065
810 µs ± 488 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8895323477510916
1.9089993747741696
504 µs ± 26.6 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9170592551570774
1.86418831198526
551 µs ± 65.4 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8480199192902722
1.9074352452706718
502 µs ± 27.1 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9042433310454134
1.9238371265096013
528 µs ± 28.5 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9203949047458799
1.8451912478345283
694 µs ± 142 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9110383512457658
1.8905749424872877
709 µs ± 123 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.0010712461291937
1.8730913324179843
588 µs ± 44.8 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9278916565855064
1.8549047120428006
572 µs ± 57.1 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.1454243893281695
1.954262217001213
575 µs ± 77.6 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.018094793572398
1.8258876271142297
751 µs ± 123 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9738950121441763
1.8454200185068992
912 µs ± 214 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9080064857922512
1.899642305398118
734 µs ± 211 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.0583399438882457
1.8884429617789698
545 µs ± 43.9 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9450661295876013
1.8795711746834745
1.37 ms ± 480 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9573964358834333
1.9593919496591903
755 µs ± 121 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9454227109527611
1.9336313835148111
864 µs ± 257 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8791163470909731
1.9229827155695596
590 µs ± 86.4 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.848623945255243
1.8983289871995557
626 µs ± 128 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.0724451496139542
1.880654529439734
531 µs ± 38.9 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.949907274105624
1.8313554720358822
884 µs ± 407 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9016927240886459
1.881743624186996
591 µs ± 73.2 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.0428522975502288
1.860607902740477
769 µs ± 178 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8979421583723741
1.8595749389028327
556 µs ± 92.9 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8881372028405056
1.8886899790362435
541 µs ± 71.7 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9787504517363712
1.9174609932807847
548 µs ± 63.4 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9515102024073514
1.8567866536422881
501 µs ± 21.7 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9102032994396412
1.9230050099499507
672 µs ± 191 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
1.0133132850048843
1.900949107371182
699 µs ± 376 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9247467938890921
1.9279616901206698
1.74 ms ± 381 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.9512289828586543
1.9188489050607411
The slowest run took 4.12 times longer than the fastest. This could mean that an intermediate result is being cached.
856 µs ± 500 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
0.8319935173995281
1.8610914498415747

plt.figure(figsize=(16,8))


plt.subplot(1,2,1)
plt.contourf(wrange, wrange, evaluate_discriminator(w.T)[0].reshape(300,300).T)

W = sample_generator(100)
plt.plot(W[:,0],W[:,1],'g.')

W = sample_prior(prior_variance, 100)
plt.plot(W[:,0],W[:,1],'r.')
plt.axis('square')
plt.xlim([wmin,wmax])
plt.ylim([wmin,wmax])
plt.title('estimated log density ratio $\Phi^{-1}(D)$')

plt.subplot(1,2,2)
plt.contourf(wrange, wrange, (llh1+llh2+llh3).reshape(300,300).T)
plt.axis('square')
plt.xlim([wmin,wmax])
plt.ylim([wmin,wmax]);

plt.title('log likelihood');

plt.contourf(wrange, wrange, np.exp(logpost.reshape(300,300).T),cmap='gray');
plt.axis('square');
W = sample_generator(1000)
plt.plot(W[:,0],W[:,1],'.g')
plt.xlim([wmin,wmax])
plt.ylim([wmin,wmax]);
plt.title('true log posterior');

sns.set_style('whitegrid')
plt.subplot(1,2,2)

W = sample_generator(5000)
plot = sns.kdeplot(W[:,0],W[:,1])
plt.axis('square')
plot.set(xlim=(wmin,wmax))
plot.set(ylim=(wmin,wmax))
plt.title('kde of approximate posterior')

plt.subplot(1,2,1)
plt.contourf(wrange, wrange, np.exp(logpost.reshape(300,300).T),cmap='gray');
plt.axis('square');
W = sample_generator(100)
plt.plot(W[:,0],W[:,1],'.g')
plt.xlim([wmin,wmax])
plt.ylim([wmin,wmax]);
plt.title('true posterior');